קורס תכנות כתובות בזיכרון כתובות בזכרון מצביעים וכתובות מצביעים וכתובות שיעור שביעי: מבנים, הקצאת זיכרון דינאמית האופרטור &

Transcription

1 כתובות בזיכרון קורס תכנות int x = 10; char c = a ; 'a' שם x כתובת שיעור שביעי: מבנים, הקצאת זיכרון דינאמית c 1 הגדרת מצביע variable( )pointer כתובות בזכרון האופרטור & מחזיר את כתובת המשתנה בזיכרון. type *variable_name; למשתנה מצביע יש שם &x יחזיר שם כתובת x לפני השם תופיע כוכבית * כדי לסמן שזהו מצביע הטיפוס מתאר את המשתנה שמצביעים עליו &c יחזיר c char *str; מצביע ל char int *ptr; מצביע ל int double d, *pd; double ומצביע ל double מצביעים וכתובות מצביעים וכתובות int x = 10; char c = 'a'; int *iptr = &x; char *cptr = &c; שם x c כתובת ערך 10 'a' int x = 10; char c = 'a'; int *iptr = &x; char *cptr = &c; 10 x 'a' c iptr cptr iptr cptr 1

2 סיכום ביניים האופרטור * )dereference( int x = 10; char c = 'a'; int *iptr = &x; char *cptr = &c; *iptr = 30; *cptr = 'A'; ניגש לזיכרון הנמצא בכתובת מסוימת 'a' 'A' x iptr c cptr משתנה מוגדר ע"י טיפוס ושם )k )int משתנה מצביע מוגדר ע"י טיפוס ושם *ptr( )int הכוכבית מסמנת שהמשתנה הוא מצביע והטיפוס מציין את הטיפוס של המשתנה שמצביעים אליו אחרי שהגדרנו משתנה נוכל להשיג את כתובתו בעזרת האופרטור & ניתן לגשת לערך שהמצביע מצביע עליו בעזרת האופרטור * מצביעים ומערכים אריתמטיקה של מצביעים char *cptr = (char*) 2; printf("cptr before: %p\n", cptr); cptr++; printf("and after: %p\n", cptr); output cptr before: and after: קיים קשר הדוק בין מצביעים למערכים שם המערך הוא הכתובת של האיבר הראשון במערך מצביע שלא ניתן לשנות את ערכו int *iptr = (int*) 2; printf("iptr before: %p\n", iptr); cptr++; printf("and after: %p\n", iptr); output iptr before: and after: כיצד זה עובד השמה בין מערך למצביע מצביע מכיל כתובת, שם המערך הוא כתובת ניתן לבצע השמה בין המערך ומצביע int *ptr; int array[10]; הקומפיילר מתרגם גישה לאיבר במערך לגישה לכתובת האיבר המתאים = 100 array[5] הפקודה 100 = 5) + *(array תתורגם ל - ptr = array; לאחר ההשמה ניתן להשתמש ;25 במצביע = כאילו ptr[2] היה שם המערך 4; מצביע= *array ניתן להשתמש במערך כאילו היה array[5] = 100; *(array + 5) = 100; *(ptr + 5) = 100; הפעולות הבאות הן שקולות לולאות 2

3 מערך כפרמטר לפונקציה מצביעים ופונקציות ניתן להעביר כתובת )מצביע( כפרמטר לפונקציה ניתן לקבל כתובת )מצביע( כערך מוחזר כאשר מועבר מערך בפרמטר לפונקציה מועברת הכתובת של תחילת המערך לכן ניתן לשנות את איברי המערך לא ניתן לשנות את הערך של המצביע המועבר לפונקציה כמו כל משתנה אחר ניתן לשנות את המשתנה שמצביעים עליו const מצביע כערך מוחזר אין להחזיר את הכתובת של משתנה לוקאלי העברת מערך שקולה להעברת מצביע הפונקציה strstr חיפוש תו במחרוזת הפונקציה strchr מחפשת תו במחרוזת מוגדרת ב string.h מחזירה מצביע למופע הראשון של התו או NULL char* strchr(const char* str, char c) if (str == NULL) while (*str!= '\0') if (*str == c) return str; str++; אם לא קיים חיפוש תת-מחרוזת char* strstr(const char *haystack, const char *needle) int needlelen; if (*needle == '\0') return (char *) haystack; needlelen = strlen(needle); for (; (haystack = strchr(haystack, *needle))!= NULL; haystack++) if (strncmp(haystack, needle, needlelen) == 0) return (char *) haystack; 6500 str char str[] = Ding Dong ; char *res = strstr(str, Don ); 6500 D i n g D o n g \0 res printf( res=%p\n,res); printf( res=%s\n,res); הפונקציה strstr res=6505 res=dong דוגמא כמה פעמים מופיעה מילה בשיר const char *rhyme = "Humpty Dumpty sat on a wall,\n " "Humpty Dumpty had a great fall.\n " "All the king's horses,\n" "And all the king's men,\n" "Couldn't put Humpty together again.\n"; const char *humpty = "Humpty"; char *ptr = NULL; int count = 0; for (ptr = strstr(rhyme, humpty); ptr!= NULL; ptr = strstr(ptr + 1, humpty)) count++; printf("the string %s appears %d times\n", humpty, count); 3

4 נתונים של ספר הספרייה הנתונים שנרצה לשמור על כל ספר: שם מחבר מספר ISBN שפה מספר עמודים הוצאה תאריך פרסום char title[title_len], author[author_len], isbn[isbn_len], language[lang_len], publisher[publisher_len]; int pages, year, month, day; איפה הספר? פונקציה שמדפיסה פרטים של ספר void print(const char *title, const char *author, const char *isbn, const char *language, const char *publisher, int pages, int year, int month, int day) איפה הספר? מה היינו רוצים? לקבץ הגדרות של משתנים שונים תחת שם יחיד בדומה לפונקציות שמקבצות פעולות תחת שם שימוש בטיפוס החדש כאילו היה טיפוס בסיסי הגדרת משתנים, איתחול, פעולות על הטיפוס וכדומה void print(const book *b) 22 הצהרה )בעזרת דוגמא( מבנים - Structures טיפוס חדש "חבילה" של משתנה אחד או יותר תחת שם יחיד שונה ממערך, יכול להכיל משתנים מטיפוסי שונים טיפוסים בסיסיים, מערכים, מצביעים ואפילו מבנים אחרים שם הטיפוס )רשות( מאפשר לנו להתייחס לטיפוס בהמשך המשתנים )שדות( המרכיבים את הטיפוס החדש המילה השמורה struct struct book char title[title_len], author[author_len], isbn[isbn_len], language[lang_len], publisher[publisher_len]; int pages; Date publication_date; ; מהו?Date

5 הצהרה - כללי שם הטיפוס )רשות( מאפשר לנו להתייחס לטיפוס בהמשך המשתנים )שדות( המרכיבים את הטיפוס החדש המילה השמורה struct struct <Tag> <field-type> <field-name>; <field-type> <field-name>; <field-type> <field-name>; ; הצהרה תופיע בתחילת הקובץ לאחר הגדרות ה define מגדירה את התבנית הכללית של הטיפוס שימו לב, זו הצהרה על טיפוס ולא על משתנה! עבודה עם מבנים נקודה במישור זוג סדור,(, xy (,של מספרים המייצגים את מיקום הנקודה במישור נרצה למפות את הטיפוס המורכב לטיפוסים פשוטים יותר struct point double x, y; ; מכיל שני שדות x,y מהטיפוס הבסיסי double המייצגים קואורדינאטות במישור המבנה הוא טיפוס כמו char* int, double, נגדיר משתנים מהטיפוס החדש שם המשתנה שם הטיפוס struct point p; int i; double d; ; קצר יותר כתיבה מקוצרת - typedef ניתן לתת שם נרדף לטיפוסים לדוגמא: קרא לטיפוס char* גם בשם string ניתן להשתמש בשם הנרדף בכל מקום שבו השתמשנו בשם המקורי string strlen(const string str) באופן כללי: גם למבנים typedef char* string; typedef <name> <alias> typedef struct book Book; typedef struct point Point; 29 ניתן לחבר את הגדרת המבנה עם השם הנרדף וכאשר נשתמש לא חייבים את השם typedef struct double x, y; point; double distance(point p, point q) point p1, p2; 30 5

6 משתנים מטיפוס מורכב משתנים ככל המשתנים האחרים )כמעט( הגדרה איתחול השמה מצביעים קריאה לפונקציות / ערך מוחזר אם משתמשים ב typedef point p, q; point p = 1, 0.2; q = p; point *p_ptr; double distance(point p, point q) איתחול מבנים ניתן לאתחל משתנה בשורת ההגדרה על ידי: point p1 = 1.5, 2; האיתחול מתבצע לפי סדר השדות בהגדרה איתחול חלקי יגרום לשאר השדות להיות מאותחלים ל איתחול מבנים )המשך( book b = "Alice in Wonderland", // title "Lewis Carroll", // author " X", // isbn "English", // language "Tribeca Books", // publisher 100, // pages 2010, 12, 12 // date ; פעולות על מבנים הפעולות היחידות המוגדרות על מבנה הן: גישה לשדה האופרטור. )dot( כתובת המשתנה אופרטור & )כמו עבור כל משתנה אחר( מחזיר את הכתובת של השדה הראשון במבנה השמה אופרטור = ההשמה מתבצעת ע"י העתקה שדה-שדה ממשתנה אחד לשני לא מוגדרות: השוואה, פעולות אריתמטיות ולוגיות נדרש להגדיר פונקציות שימו לב לאיתחול של השדה publication_date שהוא בעצמו מהטיפוס המורכב Date גישה לשדות של מבנה מתבצעת בעזרת האופרטור. )dot( מופעל על משתנה ולא על הטיפוס גישה לשדה x במשתנה p מטיפוס point באופן כללי p.x <variable-name>.<field-name> 35 גישה לשדות של מבנה point p1, p2; מתבצעת בעזרת האופרטור. )dot( מופעל על משתנה ולא על הטיפוס שני משתנים מטיפוס point קלט של ערכי השדות x ו- y עבור המשתנה p1 חישוב ערכי השדות x ו- y של המשתנה p2 בעזרת ערכי השדות המשתנה p1 של ו- y x פלט של ערכי השדות x ו- y של המשתנה p2 scanf("%lf%lf", &p1.x, &p1.y) p2.x = 2 * p1.y; p2.y = 4 * p1.x; printf("p2 = <%g, %g>\n", p2.x, p2.y); 36 6

7 השמה כתובת של מבנה בדומה לטיפוסים אחרים נשתמש באופרטור & כדי לקבל את הכתובת של המשתנה ניתן לבצע השמה בין שני משתנים מאותו טיפוס מורכב point p1, p2; p1 = p2; העתקה של הערך במשתנה p1 למשתנה p2 point p; point *p_ptr = &p; השמה מבוצעת עבור כל השדות שקול ל: הכתובת של p מצביע ל- point בשם p_ptr point p1, p2; p1.x = p2.x; p1.y = p2.y; השוואה פעולות אחרות לא מוגדרות פעולות אחרות על מבנים תלויות בטיפוס הספציפי מה המשמעות של שוויון בין נקודות? ספרים? האופרטור == לא מוגדר עבור מבנים נממש שוויון עבור נקודות בעזרת פונקציה נקודות שוות עם ערכי ה- x וה- y שלהם שווים int equals(point p1, point p2) return p1.x == p2.x && p1.y == p2.y; נצטרך לממש אותן בעצמנו בעזרת פונקציות האופרטור == מוגדר על הטיפוס הבסיסי double כיצד נחשב מרחק בין שתי נקודות? כיצד נחשב מרחק בין שתי נקודות? מרחק בין שתי נקודות p 1 ו- p 2 מוגדר על ידי p x, y p x, y dist ( x x ) ( y y ) הפונקציה distance double distance(point p1, point p2) return sqrt( (p1.x p2.x) * (p1.x p2.x) + (p1.y p2.y) * (p1.y p2.y) ); point p, q; printf("enter x and y coord. of the first point\n"); scanf("%lf%lf", &p.x, &p.y); printf("enter x and y coord. of the second point\n"); scanf("%lf%lf", &q.x, &q.y); printf("the distance is %g\n", distance(p, q));

8 מבנים ופונקציות בדיוק כמו משתנים רגילים call by value העתקת הערך של המשתנה למשתנה המקומי בפונקציה בשביל זה צריך השמה שינוי המשתנה בתוך הפונקציה לא משפיע על המשתנה בפונקציה הקוראת ניתן גם להחזיר משתנה point *p_ptr; מצביעים למבנים נוכל להגדיר מצביע למבנה בעזרת * כפי שראינו האופרטור & פועל גם על מבנים היכן נשתמש בכל מקום שבו נרצה שהפונקציה תשנה את המבנה המקורי העברת מבנה גדול כפרמטר לפונקציה. העברת הכתובת )גודל קבוע( חוסכת שיכפול המבנה כולו דוגמא double distance(const point* p, const point* q) הפונקציה מקבלת מצביעים לשני משתנים מטיפוס point point p, q; printf("enter x and y coord. of the first point\n"); scanf("%lf%lf", &p.x, &p.y); printf("enter x and y coord. of the second point\n"); scanf("%lf%lf", &q.x, &q.y); printf("the distance is %g\n", distance(&p, &q)); מבנים ומצביעים גישה לשדות נעביר לפונקציה את הכתובות של המשתנים p ו- q נשתמש באופרטור * ל. קדימות על * ולכן צריך סוגריים שימוש ב * על מצביע למבנה יחזיר את המבנה, כדי לגשת לשדה נשתמש כעת באופרטור dot (*<struct-pointer>).<field-name> מבנה double distance(const point* p1, const point* p2) return sqrt( ((*p1).x - (*p2).x) * ((*p1).x - (*p2).x) + ((*p1).y - (*p2).y) * ((*p1).y - (*p2).y) ); מערכים של מבנים אופרטור החץ >- )סוכר תחבירי( במקום להשתמש בצירוף שדה.)מצביע*( כדי לגשת לשדה נוכל להשתמש באופרטור >- שינוי בתחביר בלבד זהו התחביר המועדף int distance(const point* p1, const point* p2) return sqrt( (p1->x p2->x) * (p1->x p2->x) + (p1->y p2->y) * (p1->y p2->y) ); point points[10]; כמו מערכים של טיפוסים בסיסיים הגדרת מערך פונקציה המאתחלת את המערך void init_points(point points[], int size) int i; for (i = 0; i < size; i++) points[i].x = i; points[i].y = i;

9 מבנה כשדה של מבנה אחר - איתחול מלבן כיצד נגדיר מלבן שצלעותיו מקבילות לצירים? בשורת ההגדרה bottom left top right rectangle rec = 5, 6, 7, 8 ; נשתמש במבנה הנקודה שכבר הגדרנו bottom_left top_right typedef struct point bottom_left, top_right; rectangle; המבנה rectangle מכיל שני שדות מטיפוס point מערך כשדה של מבנה typedef struct double coordinates[2]; point; מבנים יכולים להכיל מערך כשדה מימוש חלופי של המבנה point 51 דוגמא העברת מבנה המכיל מערך לפונקציה תגרום להעתקת כל אברי המערך שינוי המערך בתוך הפונקציה לא יגרום לשינוי המשתנה המקורי 52 הפלט יהיה [0,0] void init_point(point p) p.coordinates[0] = 1; p.coordinates[1] = 1; point p = 0,0 ; init_point(p); printf("[%g,%g]", p.coordinates[0], p.coordinates[1]); דוגמא )המשך( הפונקציה לא תשפיע על המשתנה המועבר אליה הפונקציה פועלת על העתק של המשתנה הכולל העתק של המערך כיצד נשנה את המערך המקורי? נעביר מצביע ל- point void init_point(point p) p.coordinates[0] = 1; p.coordinates[1] = 1; 53 תרגיל נממש פונקציה אשר בהינתן רשימה של מלבנים מוצאת את המלבן בעל האלכסון הגדול ביותר משתנים: 54 רשימה מערך של מלבנים )וגודלו( ערך מוחזר: כתובת המלבן המבוקש 9

10 מימוש מערך של מלבנים בזיכרון max_rect המלבנים נשמרים ברצף rect_t rect_t rect_t rect_t rect_t rect_t rect_t כל נקודה מכילה שני כל מלבן מכיל שתי נקודות point_t p double double x point_t q double y 55 rectangle* max_rect(const rectangle rectangles[], int size) double max_diagonal = 0, length; rectangle_t *result = NULL; int i; עבור כל מלבן נחשב את אורך האלכסון נזכור את האלכסון המקסימאלי שראינו עד עכשיו ואת המלבן שזהו האלכסון שלו for (i = 0; i < size; i++) length = diagonal(&rectangles[i]); if (length > max_diagonal) max_diagonal = length; result = &rectangles[i]; return result; 56 מבנים - סיכום חישוב אורך האלכסון אורך האלכסון שווה למרחק בין הנקודות המגדירות את המלבן הגדרת טיפוסי משתנים חדשים שקרובים לעולם- הבעיה double diagonal(const rectangle* rec) return distance(&rec->bottom_left, &rec->top_right); שימוש כמו בטיפוסים רגילים מערך של מבנים, מצביעים על מבנה, העברה לפונקציה וכו' מוגדרת פעולת ההשמה יש להגדיר פונקציות עבור פעולות אחרות )השוואה, אריתמטיות ועוד( נשתמש בפונקציה distance שראינו קודם הקצאת זיכרון דינאמית הקצאת זיכרון דינאמית עד עכשיו עשינו "הקצאה סטטית" הגדרנו את משתני התוכנית כבר כשכתבנו אותה הקומפיילר הקצה עבורם מקום בזיכרון בפרט, בהגדרת מערך קבענו את גודלו ולא יכולנו לשנות אותו בזמן הריצה int a[10]; ; למשל: הנחנו חסם עליון על כמות המשתנים הנדרשת

11 הקצאת זיכרון דינאמית טעות נפוצה ניסיון להגדיר מערך בגודל משתנה printf("enter number of elements\n"); scanf("%d", &size); int a[size]; ; לא תמיד כל המידע ידוע בזמן כתיבת התכנית לדוגמא, תלוי בקלט מהמשתמש ניתן להקצות זיכרון במהלך ריצת התכנית הזיכרון יוקצה באזור ה"ערימה" )heap( לא נעלם כאשר הפונקציה מסתיימת הקצאה ושחרור באחריות המתכנת הקומפיילר צריך לדעת כמה זיכרון להקצות לכל משתנה הקצאה דינאמית בשפת C מודל הזיכרון של התכנית קוד קריאה בלבד קריאה וכתיבה data מחסנית )stack( ערימה )heap( הקוד פקודות התכנית Data מחרוזות שהוגדרו ע"י המתכנת מחסנית )Stack( משמש לאיחסון משתנים לוקאליים Last In First Out (LIFO) בשליטת התכנית ערימה )Heap( בשליטת המתכנתת )היום!( 63 C מספקת לנו מנגנון בסיסי להקצאה ושחרור של זיכרון פונקציה malloc calloc free realloc מטרה מוגדרות ב stdlib.h הקצאת זיכרון בגודל מבוקש הקצאת מערך של אברים ואיתחולו ל- 0 שחרור זיכרון שהוקצה קודם לכן שינוי גודלו של זיכרון שהוקצה קודם לכן 64 הפונקציה malloc malloc דוגמא void *malloc(int nbytes) מקבלת את גודל הזיכרון שנרצה להקצות )בבתים( מחזירה את הכתובת לזיכרון שהוקצה NULL אם נכשלה תמיד יש לבדוק אם הקצאת הזיכרון הצליחה או נכשלה 65 הקצאה דינאמית של זיכרון בגודל int 10 int *a = (int*) malloc(10 * sizeof(int)); האופרטור sizeof מחזיר את הגודל )בבתים( של הטיפוס המבוקש הפונקציה מחזירה כתובת )void*( באחריותנו להמיר את המצביע לטיפוס המתאים 66 11

12 שימוש ב malloc type *var-name = (type*) malloc(amount * sizeof(type)); גודל הטיפוס בבתים המרת הערך המוחזר לטיפוס המתאים מצביע לתחילת הזיכרון המוקצה הערך המוחזר הוא כתובת כלשהי ללא ציון הטיפוס כדי להשתמש במצביע יש לבצע המרה )casting( הפונקציה free שיחרור זיכרון באחריות המתכנת לשחרר זיכרון שהוקצה דינאמית -ptr מצביע לזיכרון שהוקצה דינאמית או realloc אחרת void free(void *ptr) malloc, ערך מוחזר מקריאה ל- calloc -ptr שגיאה אין שיחרור חלקי של זיכרון הקצאת מערך בגודל משתנה הקצאת מערך בגודל משתנה int *a, size, i; printf("enter array size\n"); scanf("%d", &size); קרא גודל מערך מהמשתמש הקצאת זיכרון בגודל המבוקש a = (int*) malloc(size * sizeof(int)); if (a == NULL) return 1; בדיקה האם ההקצאה הצליחה int *a, size, i; printf("enter array size\n"); scanf("%d", &size); a = (int*) malloc(size * sizeof(int)); if (a == NULL) return 1; main a size i Stack for (i = 0; i < size; i++) scanf("%d", &a[i]); קלט מהמשתמש for (i = 0; i < size; i++) scanf("%d", &a[i]); for (i = 0; i < size; i++) printf("%d", a[i]); הדפסת תוכן המערך for (i = 0; i < size; i++) printf("%d", a[i]); Heap free(a); שיחרור הזיכרון free(a); פונקציות נוספות - calloc דוגמא void* calloc( unsigned int n, unsigned int size_el ) מקצה מערך של n איברים, כל איבר בגודל size_el בתים, כל בית מאותחל לאפס )ולכן פחות יעילה(. void* realloc( void *ptr, unsigned int size ) מקבלת מצביע לזיכרון שהוקצה דינאמית ומספר בתים size הפונקציה מקצה זיכרון בהתאם לגודל הנדרש מעתיקה את תכולת הזיכרון הישן לחדש משחררת את הזיכרון הישן בשתי הפונקציות קריאה מוצלחת תחזיר את כתובת תחילת הזיכרון המוקצה, אחרת יוחזר NULL 71 int *a, size, i; printf("enter array size\n"); scanf("%d", &size); a = (int*) calloc(size, sizeof(int)); if (a == NULL) return 1; for (i = 0; i < size; i++) scanf("%d", &a[i]); for (i = 0; i < size; i++) printf("%d", a[i]); free(a); הקצאת size אלמנטים, כל אלמנט בגודל sizeof(int) הפונקציה תאתחל את הזיכרון ל

13 - realloc דוגמא זיכרון שהוקצה דינאמית int *ptr = NULL; int size = 0, new_size = 0; scanf("%d", &size); הקצאת זיכרון ); sizeof(int) ptr = (int*) malloc( size * /* incomplete, must check if allocation succeeded */ scanf("%d", &new_size); ptr = (int*) realloc( ptr, new_size*sizeof(int) ); /* incomplete, must check if allocation succeeded */ if (ptr!= NULL) free(ptr); הקצאת חדשה שחרור זיכרון 73 int* func() int *memptr = NULL; memptr = (int*) malloc(10 * sizeof(int)); return memptr; int * ptr = func(); מותר להחזיר כתובת לזיכרון שהוקצה דינאמית if (ptr!= NULL) // do something with ptr free(ptr); ptr = NULL; memptr ptr הזיכרון שייך לתוכנית ולא לפונקציה 74 שיחרור זיכרון אפשרות א': הפונקציה שהקצתה האפשרות המועדפת הדינאמי כותב הפונקציה אחראי על הזיכרון אפשרות ב': החזרת הכתובת האחריות עוברת למי שקרא לפונקציה המקצה חובה לתעד זאת, אחרת "דליפת זיכרון" עלינו להימנע ממצב שבו יש הקצאת זיכרון אבל לא מתקיים א' או ב' 75 capacity = capacity * INCREMENT * sizeof(char); 76 מערך בגודל התחלתי כלשהו 77 יש לוודא שהקצאת הזיכרון לא נכשלה 78 13

14 קריאת קלט מהמשתמש עד לסוף השורה 79 האם נגמר המקום? 80 נקצה מערך גדול יותר 81 לא לשכוח לבדוק 82 לא לשכוח לעדכן את capacity 83 נשמור את התו שקראנו במקום המתאים 84 14

15 בסוף נוסיף 0\ 85 מחזירים זיכרון שהוקצה דינאמית באחריות הלקוח לשחרר )צריך לתעד( 86 שימוש ב readline שימוש ב readline char *line = readline(); if (line == NULL) printf("fatal error: memory allocation failed!\n"); return 1; printf("%s\n", line); free(line); קריאת שורת קלט מהמשתמש char *line = readline(); if (line == NULL) printf("fatal error: memory allocation failed!\n"); return 1; printf("%s\n", line); free(line); אם הייתה בעיה נדפיס הודעת שגיאה ונסיים שימוש ב readline שימוש ב readline char *line = readline(); if (line == NULL) printf("fatal error: memory allocation failed!\n"); return 1; שימו לב לערך המוחזר printf("%s\n", line); free(line); char *line = readline(); if (line == NULL) printf("fatal error: memory allocation failed!\n"); return 1; printf("%s\n", line); free(line); נשתמש בקלט

16 char *line = readline(); שימוש ב readline if (line == NULL) printf("fatal error: memory allocation failed!\n"); return 1; printf("%s\n", line); כשאיננו צריכים יותר את הקלט, נשחרר free(line); את הזיכרון הקצאת זיכרון - בעיות נדיר שהקצאת הזיכרון נכשלת אפשרויות לטיפול: החזרת הערך NULL מהפונקציה - כאשר תפקיד הפונקציה הוא הקצאת הזיכרון שימוש בפונקציה exit לסיום התכנית 91 הקצאה דינאמית של מערכים דו-ממדיים הקצאה דינאמית של מבנים typedef struct char *title, *author; Book; בדיוק כמו בטיפוסים בסיסיים שתי גישות אפשריות: 1. מערך של מערכים Book* newbook(const char *title, const char *author) Book *result = (Book*) malloc(sizeof(book)); /* incomplete, must check if allocation succeeded */ result->title = (char*) malloc(strlen(title) + 1); /* incomplete, must check if allocation succeeded */ strcpy(result->title, title); result->author = (char*) malloc(strlen(author) + 1); /* incomplete, must check if allocation succeeded */ strcpy(result->author, author); 2. מצביעים לתוך מערך "גדול" return result; איתחול והדפסה מערך של מערכים int rows, cols, i; int** table; void init_table(int **table, int rows, int cols) int i, j; scanf("%d%d", &rows, &cols); table = (int**) malloc(rows * sizeof(int*)); /* incomplete, must check if failed */ for (i = 0; i < rows; i++) table[i] = (int*) malloc(cols * sizeof(int)); /* incomplete, must check if failed */ init_table(table, rows, cols); print_table(table, rows, cols); for (i = 0; i < rows; i++) free(table[i]); free(table); return EXIT_SUCCESS; for (i = 0; i < rows; i++) for (j = 0; j < cols; j++) table[i][j] = (i + 1) * (j + 1); void print_table(int **table, int rows, int cols) int i, j; for (i = 0; i < rows; i++) for (j = 0; j < cols; j++) printf("%4d", table[i][j]); printf("\n");

17 הפונקציה exit מצביעים לתוך מערך גדול int rows, cols, i; int* data; int** table; scanf("%d%d", &rows, &cols); data = (int*) malloc(rows * cols * sizeof(int)); /* incomplete, must check if failed */ table = (int**) malloc(rows * sizeof(int*)); /* incomplete, must check if failed */ for (i = 0; i < rows; i++) table[i] = data + (cols * i); init_table(table, rows, cols); print_table(table, rows, cols); free(table); free(data); void exit(int status); מוגדרת ב stdlib.h מסיימת את התכנית באופן מיידי נשתמש רק כאשר מתרחשת בעיה שאין לנו שום דרך לטפל בה בדרך כלל נדפיס הודעת שגיאה למשתמש ונסיים את תכנית return EXIT_SUCCESS; 97 דוגמה לשימוש ב- exit נשנה את גודלו של מערך של int בעזרת realloc אם השינוי נכשל, נסיים את התכנית int* resize(int *array, int newsize) if (array == NULL) return array; array = (int*) realloc(array, newsize * sizeof(int)); if (array == NULL) printf("fatal error: memory allocation failed!\n"); exit(1); return array; 99 17